#include "../head.h"

/**
 * @brief 解析查询参数
 *
 * 该函数用于解析URL查询字符串，并将其解析为QueryResult结构体。
 *
 * @param query 查询字符串，格式为 "key1=value1&key2=value2&..."
 * @return QueryResult 解析后的结果，包含code、message、data1、data2、data3、data4字段
 */
QueryResult parseQueryParams(const char *query)
{
    QueryResult result = {0, "", "", "", "", ""}; // 初始化结构体
    char buffer[256];                             // 用于存储临时字符串
    strcpy(buffer, query);                        // 复制查询字符串到缓冲区

    // 使用 strtok 按 '&' 分割键值对
    char *pair = strtok(buffer, "&");
    while (pair != NULL)
    {
        // 使用 strchr 按 '=' 分割键和值
        char *key = pair;
        char *value = strchr(pair, '=');
        if (value != NULL)
        {
            *value = '\0'; // 将 '=' 替换为字符串结束符
            value++;       // 移动指针到值部分
        }

        // 根据键填充结构体
        if (strcmp(key, "code") == 0)
        {
            result.code = atoi(value); // 将字符串转换为整数
        }
        else if (strcmp(key, "message") == 0)
        {
            strncpy(result.message, value, sizeof(result.message) - 1);
            result.message[sizeof(result.message) - 1] = '\0'; // 确保字符串以 '\0' 结尾
        }
        else if (strcmp(key, "data1") == 0)
        {
            strncpy(result.data1, value, sizeof(result.data1) - 1);
            result.data1[sizeof(result.data1) - 1] = '\0';
        }
        else if (strcmp(key, "data2") == 0)
        {
            strncpy(result.data2, value, sizeof(result.data2) - 1);
            result.data2[sizeof(result.data2) - 1] = '\0';
        }
        else if (strcmp(key, "data3") == 0)
        {
            strncpy(result.data3, value, sizeof(result.data3) - 1);
            result.data3[sizeof(result.data3) - 1] = '\0';
        }
        else if (strcmp(key, "data4") == 0)
        {
            strncpy(result.data4, value, sizeof(result.data4) - 1);
            result.data4[sizeof(result.data4) - 1] = '\0';
        }
        // 继续分割下一个键值对
        pair = strtok(NULL, "&");
    }

    return result;
}
messageListStruct parseResponse(const char *query)
{
    messageListStruct result = {0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", "", time(NULL)}; // 初始化结构体
    char buffer[2048];                                                          // 用于存储临时字符串
    strcpy(buffer, query);                                                      // 复制查询字符串到缓冲区

    char *pair = strtok(buffer, "^");
    while (pair != NULL)
    {

        if (pair != NULL)
        {
            result.url = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 total
        if (pair != NULL)
        {
            result.total = atoi(pair);
            pair = strtok(NULL, "^");
        }
        if (pair != NULL)
        {
            result.Id = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 isGroup
        if (pair != NULL)
        {
            result.isGroup = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 isRead
        if (pair != NULL)
        {
            result.isRead = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 groupId
        if (pair != NULL)
        {
            result.groupId = atoi(pair);
            printf("-----------groupId:%d\n", result.groupId);
            pair = strtok(NULL, "^");
        }
        // 解析 userId
        if (pair != NULL)
        {
            result.userId = atoi(pair);
            printf("-----------userId:%d\n", result.userId);
            pair = strtok(NULL, "^");
        }
        // 解析 groupName
        if (pair != NULL)
        {
            strncpy(result.groupName, pair, sizeof(result.groupName) - 1);
            result.groupName[sizeof(result.groupName) - 1] = '\0'; // 确保字符串以 '\0' 结尾
            pair = strtok(NULL, "^");
        }

        // 解析 userName
        if (pair != NULL)
        {
            printf("01-----------userName:%s\n", pair);
            strncpy(result.userName, pair, sizeof(result.userName) - 1);
            result.userName[sizeof(result.userName) - 1] = '\0';
            pair = strtok(NULL, "^");
        }

        // 解析 message
        if (pair != NULL)
        {
            strncpy(result.message, pair, sizeof(result.message) - 1);
            result.message[sizeof(result.message) - 1] = '\0';
            pair = strtok(NULL, "^");
        }

        // 解析 timestamp
        if (pair != NULL)
        {
            struct tm tm;
            memset(&tm, 0, sizeof(tm)); // 初始化 tm 结构体
            sscanf(pair, "%d-%d-%d %d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
            tm.tm_year -= 1900; // tm_year 是从 1900 年开始的
            tm.tm_mon -= 1;     // tm_mon 是从 0 开始的
            result.timestamp = mktime(&tm);
        }
    }

    return result;
}

/**
 * @brief 使用 "&&&&" 拆分字符串，返回一个 char[][1024] 数组
 *
 * @param input 输入字符串，格式为 "field1&&&&field2&&&&..."
 * @param count 用于返回拆分后的子字符串数量
 * @return char** 返回一个动态分配的 char[][1024] 数组
 */
char **splitStringByDelimiter(const char *input, int *count)
{
    *count = 0; // 初始化计数器

    // 临时缓冲区
    char buffer[4096];
    strncpy(buffer, input, sizeof(buffer) - 1);
    buffer[sizeof(buffer) - 1] = '\0'; // 确保字符串正确终止

    // 第一次遍历，计算子字符串数量
    char *temp = strtok(buffer, "&&&&");
    while (temp != NULL)
    {
        (*count)++;
        temp = strtok(NULL, "&&&&");
    }

    // 动态分配数组
    char **result = (char **)malloc((*count) * sizeof(char *));
    for (int i = 0; i < *count; i++)
    {
        result[i] = (char *)malloc(1024 * sizeof(char));
        memset(result[i], 0, 1024); // 初始化每个子字符串
    }

    // 第二次遍历，填充数组
    strncpy(buffer, input, sizeof(buffer) - 1);
    buffer[sizeof(buffer) - 1] = '\0'; // 确保字符串正确终止
    temp = strtok(buffer, "&&&&");
    int index = 0;
    while (temp != NULL)
    {
        strncpy(result[index], temp, 1023); // 复制子字符串
        result[index][1023] = '\0';         // 确保字符串正确终止
        index++;
        temp = strtok(NULL, "&&&&");
    }

    return result;
}

chatWindowListStruct parseCharResponse(const char *query)
{
    chatWindowListStruct result = {0, 0, 0, 0, 0, 0, 0,0, "", "", "","", time(NULL)}; // 初始化结构体
    char buffer[2048];                                             // 用于存储临时字符串
    strcpy(buffer, query);                                         // 复制查询字符串到缓冲区

    char *pair = strtok(buffer, "^");
    while (pair != NULL)
    {

        if (pair != NULL)
        {
            result.url = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 total
        if (pair != NULL)
        {
            result.total = atoi(pair);
            pair = strtok(NULL, "^");
        }
        if (pair != NULL)
        {
            result.weCharId = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 GroupId
        if (pair != NULL)
        {
            result.GroupId = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 friendId
        if (pair != NULL)
        {
            result.friendId = atoi(pair);
            pair = strtok(NULL, "^");
        }

        // 解析 userId
        if (pair != NULL)
        {
            result.userId = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 sex
        if (pair != NULL)
        {
            result.sex = atoi(pair);
            pair = strtok(NULL, "^");
        }
        // 解析 消息类型
        if (pair != NULL)
        {
            result.messageType = atoi(pair);
            pair = strtok(NULL, "^");
        }

        // 解析 userName
        if (pair != NULL)
        {
            printf("02-----------userName:%s\n", pair);
            strncpy(result.userName, pair, sizeof(result.userName) - 1);
            result.userName[sizeof(result.userName) - 1] = '\0';
            pair = strtok(NULL, "^");
        }
        // 解析 niceName
        if (pair != NULL)
        {
            strncpy(result.niceName, pair, sizeof(result.niceName) - 1);
            result.niceName[sizeof(result.niceName) - 1] = '\0'; // 确保字符串以 '\0' 结尾
            pair = strtok(NULL, "^");
        }

        // 解析 message
        if (pair != NULL)
        {
            strncpy(result.message, pair, sizeof(result.message) - 1);
            result.message[sizeof(result.message) - 1] = '\0';
            pair = strtok(NULL, "^");
        }
        // 解析 文件消息后后缀名
        if (pair != NULL)
        {
            strncpy(result.format, pair, sizeof(result.format) - 1);
            result.format[sizeof(result.format) - 1] = '\0';
            pair = strtok(NULL, "^");
        }

        // 解析 timestamp
        if (pair != NULL)
        {
            struct tm tm;
            memset(&tm, 0, sizeof(tm)); // 初始化 tm 结构体
            sscanf(pair, "%d-%d-%d %d:%d:%d", &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
            tm.tm_year -= 1900; // tm_year 是从 1900 年开始的
            tm.tm_mon -= 1;     // tm_mon 是从 0 开始的
            result.timestamp = mktime(&tm);
        }
    }

    return result;
}


#define MAX_TOKENS 100  // 假设最大分割的token数量不会超过100
#define MAX_TOKEN_LENGTH 100  // 假设每个token的长度不会超过100
// 下面的代码片段展示了如何正确地实现这个函数（使用动态分配）：
char** splitStringCorrect(const char* str, const char delim, int* arrayLength) {
    char* tempStr = (char*)malloc((strlen(str) + 1) * sizeof(char));
    strcpy(tempStr, str);

    char *token = strtok(tempStr, &delim);
    int count = 0;
    while (token != NULL) {
        count++;
        token = strtok(NULL, &delim);
    }

    char** tokens = (char**)malloc(count * sizeof(char*));
    *arrayLength = count;

    strcpy(tempStr, str);
    token = strtok(tempStr, &delim);
    int index = 0;
    while (token != NULL) {
        tokens[index] = (char*)malloc((strlen(token) + 1) * sizeof(char));
        strcpy(tokens[index], token);
        index++;
        token = strtok(NULL, &delim);
    }

    free(tempStr);
    return tokens;
}
